ALMaSS  1.0
The Animal, Landscape and Man Simulation System
Newt_Juvenile Class Reference

The newt juvenile class - free living but not reproductive. More...

#include <Newt.h>

Inheritance diagram for Newt_Juvenile:
Newt_Base TAnimal TALMaSSObject Newt_Adult Newt_Female Newt_Male

Public Member Functions

 Newt_Juvenile (int a_x, int a_y, vector< unsigned > a_pond, Landscape *a_L, Newt_Population_Manager *a_NPM, unsigned a_age, bool a_reproinhib)
 Newt_Juvenile constructor. More...
 
 ~Newt_Juvenile ()
 Newt_Juvenile destructor. More...
 
virtual void ReInit (int a_x, int a_y, vector< unsigned > a_pond, Landscape *a_L, Newt_Population_Manager *a_NPM, unsigned a_age, bool a_reproinhib)
 Used to re-use an object - must be implemented in descendent classes. More...
 
virtual void Step (void)
 Newt_Juvenile Step code. This is called continuously until all animals report that they are 'DONE'. More...
 
double GetWeight ()
 Get method for m_weight. More...
 
void SetWeight (double a_weight)
 Set method for m_weight. More...
 
void InternalPesticideHandlingAndResponse ()
 For handlng of class-specific pesticide effects. More...
 
- Public Member Functions inherited from Newt_Base
 Newt_Base (int a_x, int a_y, vector< unsigned > a_pond, Landscape *a_L, Newt_Population_Manager *a_NPM, bool a_reproinhib)
 Newt constructor. More...
 
void Init (vector< unsigned > a_pond, Newt_Population_Manager *a_NPM, bool a_reproinhib)
 Intitialise object. More...
 
void ReInit (int a_x, int a_y, vector< unsigned > a_pond, Landscape *a_L, Newt_Population_Manager *a_NPM, bool a_reproinhib)
 ReInit for object pool. More...
 
 ~Newt_Base ()
 Newt destructor. More...
 
virtual int WhatState ()
 Returns the state number for display purposes. More...
 
TTypeOfNewtState st_Develop (void)
 Behavioural state development - does nothing in the base class. More...
 
TTypeOfNewtState st_Movement (void)
 Behavioural state movement - does nothing in the base class. More...
 
void st_Dying (void)
 Behavioural state dying. More...
 
virtual void BeginStep (void)
 The BeginStep is the first 'part' of the timestep that an animal can behave in. It is called once per timestep. More...
 
virtual void EndStep (void)
 The EndStep is the third 'part' of the timestep that an animal can behave in. It is called once per timestep. More...
 
unsigned GetAge ()
 A typical interface function - this one returns the Age as an unsigned integer. More...
 
void SetAge (unsigned a_age)
 A typical interface function - this one sets the Age as an unsigned integer. More...
 
unsigned GetHomePond ()
 A typical interface function - this one returns the home pond reference as an unsigned integer. More...
 
void SetHomePond (unsigned a_pond)
 A typical interface function - this one sets the home pond reference as an unsigned integer. More...
 
void InternalPesticideHandlingAndResponse (double)
 For handlng of class-specific pesticide effects. More...
 
- Public Member Functions inherited from TAnimal
unsigned SupplyFarmOwnerRef ()
 
AnimalPosition SupplyPosition ()
 
APoint SupplyPoint ()
 
int SupplyPolygonRef ()
 
int Supply_m_Location_x ()
 
int Supply_m_Location_y ()
 
virtual void KillThis ()
 
virtual void CopyMyself ()
 
void SetX (int a_x)
 
void SetY (int a_y)
 
 TAnimal (int x, int y, Landscape *L)
 
virtual void ReinitialiseObject (int x, int y, Landscape *L)
 Used to re-use an object - must be implemented in descendent classes. More...
 
virtual void Dying ()
 
void CheckManagement (void)
 
void CheckManagementXY (int x, int y)
 
virtual bool OnFarmEvent (FarmToDo)
 
- Public Member Functions inherited from TALMaSSObject
int GetCurrentStateNo ()
 Returns the current state number. More...
 
void SetCurrentStateNo (int a_num)
 Sets the current state number. More...
 
bool GetStepDone ()
 Returns the step done indicator flag. More...
 
void SetStepDone (bool a_bool)
 Sets the step done indicator flag. More...
 
virtual void ReinitialiseObject ()
 Used to re-use an object - must be implemented in descendent classes. More...
 
 TALMaSSObject ()
 The constructor for TALMaSSObject. More...
 
virtual ~TALMaSSObject ()
 The destructor for TALMaSSObject. More...
 
void OnArrayBoundsError ()
 Used for debugging only, tests basic object properties. More...
 

Static Public Attributes

static double m_JuvenilePPPThreshold_Min = 0
 The minimum threshold for effect of PPP on juveniles. More...
 
static double m_JuvenilePPPThreshold_EnvConc = cfg_NewtJuvenilePPPToxTrigger_EnvConc.value()
 The environmental concentration threshold for effect of PPP on juveniles. More...
 
static double m_JuvenilePPPThreshold_Overspray = cfg_NewtJuvenilePPPToxTrigger_Overspray.value()
 The overspray threshold for effect of PPP on juveniles. More...
 
static double m_JuvenilePPPElimRate = cfg_NewtJuvenilePPPToxEliminationRate.value()
 The daily proportion of PPP body burden that is not eliminated for juveniles. More...
 
static double m_JuvenilePPPEffectProbability_EnvConc = cfg_NewtJuvenilePPPEffectProbability_EnvConc.value()
 The daily probability of effect if above m_JuvenilePPPThreshold for juveniles for environmental concentration. More...
 
static double m_JuvenilePPPEffectProbability_Overspray = cfg_NewtJuvenilePPPEffectProbability_Overspray.value()
 The daily probability of effect if above m_JuvenilePPPThreshold for juveniles for overspray. More...
 
static double m_JuvenileDailyWeightGain = cfg_NewtJuvenileDailyLengthGain.value()
 Used in determining daily growth. More...
 
static int m_SimW = 0
 The width of the simulation map, stored for fast access. More...
 
static int m_SimH = 0
 The height of the simulation map, stored for fast access. More...
 
static double m_roadmortalityprob = cfg_NewtRoadMortalityProb.value()
 The probability of death when crossing a road. More...
 
static int m_newtwalkspeed = cfg_NewtWalkSpeed.value()
 The max walking speed of a newt. More...
 
static int m_newtwalkstepsize = cfg_NewtWalkStepsize.value()
 The size of a step when evaluating habitat during walking. More...
 
static double m_goodhabitatdispersalprob = cfg_newtgoodhabitatdispersalprob.value()
 Probability of dispersal in good habitat. More...
 
static double m_poorhabitatdispersalprob = cfg_newtpoorhabitatdispersalprob.value()
 Probability of dispersal in poor habitat. More...
 
static double m_NewtDormancyTemperature = cfg_newtdormancytemp.value()
 Temperature in degrees that the newts become dormant. More...
 
static double m_NewtDormancyHumidity = cfg_newtdormancyhumidity.value()
 Temperature in degrees that the newts become dormant. More...
 
- Static Public Attributes inherited from Newt_Base
static double m_EggDevelopmentDDTotal = cfg_NewtEggDevelTotal.value()
 
static double m_EggDevelopmentDDParameter = cfg_NewtEggDevelDDParameter.value()
 
static double m_JuvenileDevelopmentSize = cfg_NewtJuvenileDevelSize.value()
 
static double m_EggMortalityChance = cfg_NewtEggMortalityChance.value()
 
static double m_JuvenileMortalityChance = 0.0
 
static double m_AdultMortalityChance = 0.0
 
static bool m_test_pesticide_egg = cfg_Newt_Test_Pesticide_Egg.value()
 Flags to record whether we are in pesticide testing mode. More...
 
static bool m_test_pesticide_larva = cfg_Newt_Test_Pesticide_Larva.value()
 
static bool m_test_pesticide_terrestrial = cfg_Newt_Test_Pesticide_Terrestrial.value()
 

Protected Member Functions

virtual TTypeOfNewtState st_Develop (void)
 Juvenile development state. More...
 
virtual TTypeOfNewtState st_EvaluateHabitat (void)
 Juvenile evaluate habitat behaviour. More...
 
virtual TTypeOfNewtState st_Disperse (void)
 Juvenile dispersal state. More...
 
virtual TTypeOfNewtState st_Overwinter (void)
 Juvenile overwintering state. More...
 
virtual TTypeOfNewtState st_NextStage (void)
 Juvenile maturation. More...
 
void MoveTo (TTypeDirectedWalk a_directedness, int a_stepsize, int a_steps)
 Top level control of newt movement. More...
 
void NewtDoWalking (int &a_vector, int a_stepsize, int a_steps, int &vx, int &vy)
 This method moves the newt through the landscape. More...
 
void NewtDoWalkingCorrect (int &a_vector, int a_stepsize, int a_steps, int &vx, int &vy)
 This method moves the newt through the landscape using wrap around corrects. More...
 
int NewtMoveQuality (int a_x, int a_y, TTypesOfLandscapeElement &a_tole)
 Tests the habitat quality for a square to move to. More...
 
- Protected Member Functions inherited from TAnimal
void CorrectWrapRound ()
 Corrects wrap around co-ordinate problems. More...
 

Protected Attributes

int m_InPond
 The polyrefindex for the pond the newt is in, or -1 if not in a pond. More...
 
double m_weight
 
unsigned m_OurVector
 The last direction we moved in. More...
 
TTypesOfLandscapeElement m_CurrentHabitat
 The current habitat type the newt is in. More...
 
bool m_forcedisperse
 A flag to force dispersal from the breeding ponds. More...
 
- Protected Attributes inherited from Newt_Base
TTypeOfNewtState m_CurrentNewtState
 Variable to record current behavioural state. More...
 
unsigned m_Age
 
vector< unsigned > m_pondlist
 
Newt_Population_Managerm_OurPopulationManager
 This is a time saving pointer to the correct population manager object. More...
 
double m_body_burden
 The current PPP body burden for use in pesticide testing mode. More...
 
bool m_reproductiveinhibition
 A flag to indicate environmentally induced reproductive inhibition (value is inherited by descendent classes) More...
 
- Protected Attributes inherited from TAnimal
int m_Location_x
 
int m_Location_y
 
Landscapem_OurLandscape
 
- Protected Attributes inherited from TALMaSSObject
int m_CurrentStateNo
 The basic state number for all objects - '-1' indicates death. More...
 
bool m_StepDone
 Indicates whether the iterative step code is done for this timestep. More...
 

Detailed Description

The newt juvenile class - free living but not reproductive.

Constructor & Destructor Documentation

◆ Newt_Juvenile()

Newt_Juvenile::Newt_Juvenile ( int  a_x,
int  a_y,
vector< unsigned >  a_pond,
Landscape a_L,
Newt_Population_Manager a_NPM,
unsigned  a_age,
bool  a_reproinhib 
)

Newt_Juvenile constructor.

Newt_Juvenile constructor Assigns default values to specific juvenile attributes and passes the age of the juvenile from the age of the larva.

326  : Newt_Base(a_x, a_y, a_pond, a_L, a_NPM, a_reproinhib)
327 {
332  m_OurVector = unsigned (floor(g_rand_uni()*7.0 +0.5));
333  m_forcedisperse = false;
334  m_Age = a_age;
335 }
boost::variate_generator< base_generator_type &, boost::uniform_real<> > g_rand_uni
static CfgFloat cfg_newtJuvenileStartSize("NEWT_JUVESTARTSIZE", CFG_CUSTOM, 42.3)
Based on Baker (1998), the start size is the snout-vent length averaging 42.3mm after metamorphosis.
double value(void)
Definition: configurator.h:118
unsigned m_Age
Definition: Newt.h:115
Newt_Base(int a_x, int a_y, vector< unsigned > a_pond, Landscape *a_L, Newt_Population_Manager *a_NPM, bool a_reproinhib)
Newt constructor.
Definition: Newt.cpp:59
double m_weight
Definition: Newt.h:365
bool m_forcedisperse
A flag to force dispersal from the breeding ponds.
Definition: Newt.h:371
unsigned m_OurVector
The last direction we moved in.
Definition: Newt.h:367

References cfg_newtJuvenileStartSize, g_rand_uni, Newt_Base::m_Age, m_forcedisperse, m_OurVector, m_weight, and CfgFloat::value().

◆ ~Newt_Juvenile()

Newt_Juvenile::~Newt_Juvenile ( void  )

Newt_Juvenile destructor.

339 {
340  ;
341 }

Member Function Documentation

◆ GetWeight()

double Newt_Juvenile::GetWeight ( )
inline

Get method for m_weight.

351  {
352  return m_weight;
353  }

References m_weight.

◆ InternalPesticideHandlingAndResponse()

void Newt_Juvenile::InternalPesticideHandlingAndResponse ( )

For handlng of class-specific pesticide effects.

This method is re-implemented from Newt_Base for any class which has pesticide response behaviour. If the body burden exceeds the trigger then an effect is tested for and implemented depending on the pesticide type.

m_JuvenilePPPThreshold_Min holds the lowest trigger of any multiple effects - but we need to figure out which we have and respond accordingly there are two possibilities - a env. concentration trigger and an overspray trigger

1228  {
1233  // Test against the threshold level for Juvenile to determine if an effect needs to be tested for
1235  // We are above the PPP body burden threshold, so make a test for effect
1237  switch (tp) {
1238  case ttop_NoPesticide:
1239  break;
1240  case ttop_ReproductiveEffects: // Reproductive effects
1242  m_reproductiveinhibition = true;
1243  }
1244  break;
1245  case ttop_AcuteEffects: // Acute mortality
1248  KillThis();
1249  }
1250  break;
1251  case ttop_MultipleEffects:
1255  // Are we in an overspray situation?
1257  // If so, have we exceeded the overspray trigger
1261  KillThis();
1262  }
1263  }
1264  }
1265  // Not overspray so test the env conc trigger
1269  KillThis();
1270  }
1271  }
1272  break;
1273  default:
1274  g_msg->Warn("Unknown pesticide type used in Newt_Juvenile::InternalPesticideHandlingAndResponse() pesticide code ", int(tp));
1275  exit(47);
1276  }
1277  }
1278 }
MapErrorMsg * g_msg
This pointer provides access the to the internal ALMaSS error message system.
Definition: maperrormsg.cpp:41
@ toNewts_Die
Definition: Newt.h:75
bool SupplyOverspray(int a_x, int a_y)
Gets the overspray flag.
Definition: Landscape.cpp:599
TTypesOfPesticide SupplyPesticideType(void)
Definition: landscape.h:433
void Warn(MapErrorState a_level, std::string a_msg1, std::string a_msg2)
Definition: maperrormsg.cpp:59
TTypeOfNewtState m_CurrentNewtState
Variable to record current behavioural state.
Definition: Newt.h:113
bool m_reproductiveinhibition
A flag to indicate environmentally induced reproductive inhibition (value is inherited by descendent ...
Definition: Newt.h:123
double m_body_burden
The current PPP body burden for use in pesticide testing mode.
Definition: Newt.h:121
static double m_JuvenilePPPEffectProbability_EnvConc
The daily probability of effect if above m_JuvenilePPPThreshold for juveniles for environmental conce...
Definition: Newt.h:318
static double m_JuvenilePPPThreshold_Overspray
The overspray threshold for effect of PPP on juveniles.
Definition: Newt.h:314
static double m_JuvenilePPPEffectProbability_Overspray
The daily probability of effect if above m_JuvenilePPPThreshold for juveniles for overspray.
Definition: Newt.h:320
static double m_JuvenilePPPThreshold_EnvConc
The environmental concentration threshold for effect of PPP on juveniles.
Definition: Newt.h:312
static double m_JuvenilePPPThreshold_Min
The minimum threshold for effect of PPP on juveniles.
Definition: Newt.h:310
int m_Location_y
Definition: PopulationManager.h:228
virtual void KillThis()
Definition: PopulationManager.h:219
int m_Location_x
Definition: PopulationManager.h:225
Landscape * m_OurLandscape
Definition: PopulationManager.h:229
TTypesOfPesticide
Definition: landscape.h:66
@ ttop_NoPesticide
Definition: landscape.h:67
@ ttop_AcuteEffects
Definition: landscape.h:68
@ ttop_MultipleEffects
Definition: landscape.h:74
@ ttop_ReproductiveEffects
Definition: landscape.h:69

References g_msg, g_rand_uni, TAnimal::KillThis(), Newt_Base::m_body_burden, Newt_Base::m_CurrentNewtState, m_JuvenilePPPEffectProbability_EnvConc, m_JuvenilePPPEffectProbability_Overspray, m_JuvenilePPPThreshold_EnvConc, m_JuvenilePPPThreshold_Min, m_JuvenilePPPThreshold_Overspray, TAnimal::m_Location_x, TAnimal::m_Location_y, TAnimal::m_OurLandscape, Newt_Base::m_reproductiveinhibition, Landscape::SupplyOverspray(), Landscape::SupplyPesticideType(), toNewts_Die, ttop_AcuteEffects, ttop_MultipleEffects, ttop_NoPesticide, ttop_ReproductiveEffects, and MapErrorMsg::Warn().

Referenced by st_Develop().

◆ MoveTo()

void Newt_Juvenile::MoveTo ( TTypeDirectedWalk  a_directedness,
int  a_stepsize,
int  a_steps 
)
protected

Top level control of newt movement.

This is part of the movement method for all newts. It checks whether there is any need to consider wrap-around and then calls movement the appropriate number of times passing a_vector, which is used to determine the direction (if any), and a_directedness, which determines the degree of directed movement:

  • directedwalk_totally = 1,
  • directedwalk_high = 3,
  • directedwalk_medium = 5,
  • directedwalk_low = 7,
  • directedwalk_random = 8
509  {
519  int direction = int( g_rand_uni()*a_directedness + m_OurVector ) & 0x07;
520  int MaxPossDistance = a_stepsize*a_steps;
521  if ((m_Location_x - MaxPossDistance < 0) || (m_Location_x + MaxPossDistance >= m_SimW) || (m_Location_y - MaxPossDistance < 0) || (m_Location_y + MaxPossDistance >= m_SimH)) {
522  // Need correct coords
523  // Make sure that the coords can't become -ve
524  int vx = m_Location_x + m_SimW;
525  int vy = m_Location_y + m_SimH;
526  NewtDoWalkingCorrect( direction, a_stepsize, a_steps, vx, vy );
527  m_Location_x = vx % m_SimW;
528  m_Location_y = vy % m_SimH;
529  }
530  else {
531  // Don't need correct coords
532  int vx = m_Location_x;
533  int vy = m_Location_y;
534  NewtDoWalking( direction, a_stepsize, a_steps, vx, vy );
535  // alter the voles location (& correct coords)
536  m_Location_x = vx;
537  m_Location_y = vy;
538  }
539 }
static int m_SimW
The width of the simulation map, stored for fast access.
Definition: Newt.h:324
void NewtDoWalking(int &a_vector, int a_stepsize, int a_steps, int &vx, int &vy)
This method moves the newt through the landscape.
Definition: Newt.cpp:542
static int m_SimH
The height of the simulation map, stored for fast access.
Definition: Newt.h:326
void NewtDoWalkingCorrect(int &a_vector, int a_stepsize, int a_steps, int &vx, int &vy)
This method moves the newt through the landscape using wrap around corrects.
Definition: Newt.cpp:595

References g_rand_uni, TAnimal::m_Location_x, TAnimal::m_Location_y, m_OurVector, m_SimH, m_SimW, NewtDoWalking(), and NewtDoWalkingCorrect().

Referenced by st_Disperse(), Newt_Adult::st_Disperse(), and Newt_Adult::st_Migrate().

◆ NewtDoWalking()

void Newt_Juvenile::NewtDoWalking ( int &  a_vector,
int  a_stepsize,
int  a_steps,
int &  vx,
int &  vy 
)
protected

This method moves the newt through the landscape.

This method does the actual stepping - there is no look ahead here, so steps are taken one at a time based on the habitat type and vector given. This is a very time critical method. The relative locations of each direction compared to the present x,y, are stored in StepsX and StepsY. These locations use the step size. For the newt we only care whether they can walk there, and if we are on a road. So it will rarely necessary to test more than a single location, hence this implementation differs from e.g. vole, that makes decisions based on habitat choice. For the newt this is more based on whether to move and how much than active choices.

Parameters
a_vector[in] The initial direction to move in.
a_steps[in] The number of steps to take
a_stepsize[in] The size of each step in m - this effectively allows the newt to skip over testing each and every step
vx[in][out] The starting x-coordinate for the movement
vy[in][out] The starting y-coordinate for the movement

If a newt steps onto a road then the chance of mortality is dependent on an external parameter stored in m_roadmortalityprob This value is multiplied by the return value of NewtMoveQuality which will increase with the size of the road (or could be linked to traffic information in the future).

542  {
559  int StepsX;
560  int StepsY;
561  int testquality;
563 
564  StepsX = Vector_x[ a_vector ] * a_stepsize;
565  StepsY = Vector_y[ a_vector ] * a_stepsize;
566  for (int i = 0; i < a_steps; i++) {
567  // test the squares at Vector, Vector+1+2, Vector-1-2
568  // They have either a quality or are inaccessible (water,buildings)
569  // if can go to one of these squares then pick the best one
570  // if all or some are equal then take a random pick.
571  // if all are 'bad' then add or subtract one from vector and try again
572  testquality = NewtMoveQuality( (vx + StepsX), (vy + StepsY), tole );
573  if (testquality == -1) {
574  // can't go anywhere so change the vector
575  if (random( 2 )) ++a_vector; else (--a_vector);
576  a_vector &= 0x07;
577  }
578  else {
579  if (testquality > 0) {
580  // On a dangerous habitat. take a mortality test
581  if (g_rand_uni() < m_roadmortalityprob * testquality) {
583  return;
584  }
585  }
586  // change co-ordinates
587  vx += StepsX;
588  vy += StepsY;
589  m_CurrentHabitat = tole;
590  }
591  }
592 }
int random(int a_range)
Definition: ALMaSS_CmdLine.cpp:142
const int Vector_x[8]
const int Vector_y[8]
static double m_roadmortalityprob
The probability of death when crossing a road.
Definition: Newt.h:328
int NewtMoveQuality(int a_x, int a_y, TTypesOfLandscapeElement &a_tole)
Tests the habitat quality for a square to move to.
Definition: Newt.cpp:648
TTypesOfLandscapeElement m_CurrentHabitat
The current habitat type the newt is in.
Definition: Newt.h:369
TTypesOfLandscapeElement
Definition: tole_declaration.h:36

References g_rand_uni, m_CurrentHabitat, Newt_Base::m_CurrentNewtState, m_roadmortalityprob, NewtMoveQuality(), random(), toNewts_Die, Vector_x, and Vector_y.

Referenced by MoveTo().

◆ NewtDoWalkingCorrect()

void Newt_Juvenile::NewtDoWalkingCorrect ( int &  a_vector,
int  a_stepsize,
int  a_steps,
int &  vx,
int &  vy 
)
protected

This method moves the newt through the landscape using wrap around corrects.

This method does the actual stepping. It is identical to NewtDoWalking except it corrects for warparound issues. There is no look ahead here, so steps are taken one at a time based on the habitat type and vector given. This is a very time critical method. The relative locations of each direction compared to the present x,y, are stored in StepsX and StepsY. These locations use the step size. For the newt we only care whether they can walk there, and if we are on a road. So it will rarely necessary to test more than a single location, hence this implementation differs from e.g. vole, that makes decisions based on habitat choice. For the newt this is more based on whether to move and how much than active choices.

Parameters
a_vector[in] The initial direction to move in.
a_steps[in] The number of steps to take
a_stepsize[in] The size of each step in m - this effectively allows the newt to skip over testing each and every step
vx[in][out] The starting x-coordinate for the movement
vy[in][out] The starting y-coordinate for the movement

If a newt steps onto a road then the chance of mortality is dependent on an external parameter stored in m_roadmortalityprob This value is multiplied by the return value of NewtMoveQuality which will increase with the size of the road (or could be linked to traffic information in the future).

595  {
613  int StepsX;
614  int StepsY;
615  int testquality;
617  StepsX = Vector_x[ a_vector ] * a_stepsize + m_SimW;
618  StepsY = Vector_x[ a_vector ] * a_stepsize + m_SimH;
619  for (int i = 0; i < a_steps; i++) {
620  // test the squares at Vector, Vector+1+2, Vector-1-2
621  // They have either a quality or are inaccessible (water,buildings)
622  // if can go to one of these squares then pick the best one
623  // if all or some are equal then take a random pick.
624  // if all are 'bad' then add or subtract one from vector and try again
625  testquality = NewtMoveQuality( (vx + StepsX) % m_SimW, (vy + StepsY) % m_SimH, tole );
626  if (testquality == -1) {
627  // can't go anywhere so change the vector
628  if (random( 2 )) ++a_vector; else (--a_vector);
629  a_vector &= 0x07;
630  }
631  else {
632  if (testquality > 0) {
633  // On a dangerous habitat. take a mortality test
636  return;
637  }
638  }
639  // change co-ordinates and save the current habitat type we are in
640  vx += (m_SimW + StepsX) % m_SimW;
641  vy += (m_SimH + StepsY) % m_SimH;
642  m_CurrentHabitat = tole;
643  }
644  }
645 }

References g_rand_uni, m_CurrentHabitat, Newt_Base::m_CurrentNewtState, m_roadmortalityprob, m_SimH, m_SimW, NewtMoveQuality(), random(), toNewts_Die, and Vector_x.

Referenced by MoveTo().

◆ NewtMoveQuality()

int Newt_Juvenile::NewtMoveQuality ( int  a_x,
int  a_y,
TTypesOfLandscapeElement a_tole 
)
protected

Tests the habitat quality for a square to move to.

This is where the movement onto a habitat is evaluted and either returns a yes can move here, a n cannot move hereo, or a yes with a mortality chance. If the habitat is breeding habitat this is recorded otherwise

648  {
653  unsigned poly_index = m_OurLandscape->SupplyPolyRefIndex( a_x, a_y );
654  a_tole = m_OurLandscape->SupplyElementTypeFromVector( poly_index );
655  switch (a_tole) {
656  case tole_UrbanNoVeg:
657  case tole_Building: // 5
658  case tole_River: // 96
659  case tole_Saltmarsh: // 95
660  case tole_Saltwater: // 80
661  case tole_Coast: // 100
662  return -1; // Cannot move here
663  case tole_SmallRoad: // 122
664  m_InPond = -1;
665  return 1; // Road mortality x1
666  case tole_LargeRoad: // 121
667  m_InPond = -1;
668  return 2; // Road mortality x2
669  case tole_Pond:
670  {
671  m_InPond = poly_index;
672  bool found = false;
673  for (unsigned p = 0; p < m_pondlist.size(); p++)
674  if (m_pondlist[ p ] == poly_index) found = true;
675  if (!found) m_pondlist.push_back( poly_index );
676  }
677  return 0;
678  default:
679  m_InPond = -1;
680  return 0; // Can move here
681  }
682 }
TTypesOfLandscapeElement SupplyElementTypeFromVector(unsigned int a_index)
Definition: landscape.h:1104
int SupplyPolyRefIndex(int a_x, int a_y)
Definition: landscape.h:1493
vector< unsigned > m_pondlist
Definition: Newt.h:117
int m_InPond
The polyrefindex for the pond the newt is in, or -1 if not in a pond.
Definition: Newt.h:363
@ tole_Saltmarsh
Definition: tole_declaration.h:88
@ tole_Coast
Definition: tole_declaration.h:67
@ tole_UrbanNoVeg
Definition: tole_declaration.h:78
@ tole_Saltwater
Definition: tole_declaration.h:66
@ tole_River
Definition: tole_declaration.h:65
@ tole_Pond
Definition: tole_declaration.h:101
@ tole_Building
Definition: tole_declaration.h:62
@ tole_SmallRoad
Definition: tole_declaration.h:60
@ tole_LargeRoad
Definition: tole_declaration.h:61

References m_InPond, TAnimal::m_OurLandscape, Newt_Base::m_pondlist, Landscape::SupplyElementTypeFromVector(), Landscape::SupplyPolyRefIndex(), tole_Building, tole_Coast, tole_LargeRoad, tole_Pond, tole_River, tole_Saltmarsh, tole_Saltwater, tole_SmallRoad, and tole_UrbanNoVeg.

Referenced by NewtDoWalking(), and NewtDoWalkingCorrect().

◆ ReInit()

void Newt_Juvenile::ReInit ( int  a_x,
int  a_y,
vector< unsigned >  a_pond,
Landscape a_L,
Newt_Population_Manager a_NPM,
unsigned  a_age,
bool  a_reproinhib 
)
virtual

Used to re-use an object - must be implemented in descendent classes.

Reimplemented in Newt_Female, Newt_Male, and Newt_Adult.

344  {
345  Newt_Base::ReInit(a_x, a_y, a_pond, a_L, a_NPM, a_reproinhib);
347  m_OurVector = unsigned(floor(g_rand_uni()*7.0 + 0.5));
348  m_forcedisperse = false;
349  m_Age = a_age;
350 }
void ReInit(int a_x, int a_y, vector< unsigned > a_pond, Landscape *a_L, Newt_Population_Manager *a_NPM, bool a_reproinhib)
ReInit for object pool.
Definition: Newt.cpp:65

References cfg_newtJuvenileStartSize, g_rand_uni, Newt_Base::m_Age, m_forcedisperse, m_OurVector, m_weight, Newt_Base::ReInit(), and CfgFloat::value().

Referenced by Newt_Population_Manager::CreateObjects(), and Newt_Adult::ReInit().

◆ SetWeight()

void Newt_Juvenile::SetWeight ( double  a_weight)
inline

Set method for m_weight.

355  {
356  m_weight = a_weight;
357  }

References m_weight.

Referenced by Newt_Population_Manager::CreateObjects().

◆ st_Develop()

TTypeOfNewtState Newt_Juvenile::st_Develop ( void  )
protectedvirtual

Juvenile development state.

First determines whether the juvenile sucumbs to daily mortality, if so return toNewts_Die state.
Next if there is the need to test for pesticide effects then the body-burden is adjusted for yesterdays elimination, then pesticide at this location is determined and any intake stored. If the body-burden is greater than the threshold for effects, then InternalPesticideHandlingAndResponse is called and the impacts determined. If the juvenile survives:

  • The age is incremented
  • Length is added as a daily increment based on an input parameter
  • If the total length exceeds the parameter value held in m_JuvenileDevelopmentSize, the juvenile should mature and the state toNewts_NextStage is returned
  • the behavioural state st_EvaluateHabitat is called following st_Develop, which leads to either a dispersal state or return to this state on the next day.
  • If the newt is in pond then dispersal if forced.

Reimplemented in Newt_Female, Newt_Male, and Newt_Adult.

412  {
427  // We need to test pesticide if m_test_pesticide is set
429  // Eliminate some/all of yesterdays body burden of PPP by multiplying by 1-the daily elimination rate
431  // Pick up the pesticide to add to the body burden
433  // Test against the threshold level for adult to determine if an effect needs to be tested for
436  }
437  m_Age++; // we get older but not heavier if cold
439  return toNewts_Overwinter;
440  }
443  if (m_InPond) m_forcedisperse = true;
445 }
@ toNewts_NextStage
Definition: Newt.h:69
@ toNewts_EvaluateLocation
Definition: Newt.h:68
@ toNewts_Overwinter
Definition: Newt.h:74
class Calendar * g_date
Definition: calendar.cpp:38
long Date(void)
Definition: calendar.h:57
double SupplyPesticide(int a_x, int a_y, PlantProtectionProducts a_ppp)
Gets total pesticide for a location.
Definition: Landscape.cpp:586
double SupplyTempPeriod(long a_date, int a_period)
Definition: landscape.h:1410
static bool m_test_pesticide_terrestrial
Definition: Newt.h:108
static double m_JuvenileMortalityChance
Definition: Newt.h:103
static double m_JuvenileDevelopmentSize
Definition: Newt.h:101
static double m_JuvenilePPPElimRate
The daily proportion of PPP body burden that is not eliminated for juveniles.
Definition: Newt.h:316
void InternalPesticideHandlingAndResponse()
For handlng of class-specific pesticide effects.
Definition: Newt.cpp:1228
static double m_JuvenileDailyWeightGain
Used in determining daily growth.
Definition: Newt.h:322
static double m_NewtDormancyTemperature
Temperature in degrees that the newts become dormant.
Definition: Newt.h:338
@ ppp_1
Definition: farm.h:422

References Calendar::Date(), g_date, g_rand_uni, InternalPesticideHandlingAndResponse(), Newt_Base::m_Age, Newt_Base::m_body_burden, Newt_Base::m_CurrentNewtState, m_forcedisperse, m_InPond, m_JuvenileDailyWeightGain, Newt_Base::m_JuvenileDevelopmentSize, Newt_Base::m_JuvenileMortalityChance, m_JuvenilePPPElimRate, TAnimal::m_Location_x, TAnimal::m_Location_y, m_NewtDormancyTemperature, TAnimal::m_OurLandscape, Newt_Base::m_test_pesticide_terrestrial, m_weight, ppp_1, Landscape::SupplyPesticide(), Landscape::SupplyTempPeriod(), toNewts_Die, toNewts_EvaluateLocation, toNewts_NextStage, and toNewts_Overwinter.

Referenced by Step().

◆ st_Disperse()

TTypeOfNewtState Newt_Juvenile::st_Disperse ( void  )
protectedvirtual

Juvenile dispersal state.

The newt can only move around when the humidity is high. Here we assume this is related to the rainfall and temperature of the preceding days. If the humidity is high enough then the newt moves otherwise it stays where it is and returns toNewts_Develop.
The newt moves around using a random walk. At each step it evaluates if the habitat is walks onto is legal (if not it does not move), and if a pond it remembers this. The new pond is added to the m_pondlist vector.
The rate of the random walk is set by a input parameter stored in the static attribute m_newtwalkspeed, and is a uniform random distribution between 0 and this value. During the dispersal roads have associated mortality risks. These are flagged and probability tests taken.
If killed in dispersal, the current state will be changed to die by MoveTo->NewtDoWalking, so if this has been altered from toNewts_Dispersal then return the new state, otherwise returns toNewts_Develop.

Reimplemented in Newt_Adult.

448  {
459  TTypeDirectedWalk directedness = directedwalk_random;
460  if (m_forcedisperse) directedness = directedwalk_high;
461  double temp = m_OurLandscape->SupplyTempPeriod(g_date->Date(), 5);
462  double humidity = m_OurLandscape->SupplyHumidity();
463  if ((temp > m_NewtDormancyTemperature) && (humidity > m_NewtDormancyHumidity))
464  {
465  MoveTo(directedness, m_newtwalkstepsize, int(m_newtwalkspeed*g_rand_uni()));
467  }
468  return toNewts_Develop;
469 }
TTypeDirectedWalk
Newt types of movement.
Definition: Newt.h:80
@ directedwalk_high
Definition: Newt.h:82
@ directedwalk_random
Definition: Newt.h:85
@ toNewts_Develop
Definition: Newt.h:67
double SupplyHumidity(void)
Definition: landscape.h:1393
static int m_newtwalkstepsize
The size of a step when evaluating habitat during walking.
Definition: Newt.h:332
static int m_newtwalkspeed
The max walking speed of a newt.
Definition: Newt.h:330
static double m_NewtDormancyHumidity
Temperature in degrees that the newts become dormant.
Definition: Newt.h:340
void MoveTo(TTypeDirectedWalk a_directedness, int a_stepsize, int a_steps)
Top level control of newt movement.
Definition: Newt.cpp:509

References Calendar::Date(), directedwalk_high, directedwalk_random, g_date, g_rand_uni, Newt_Base::m_CurrentNewtState, m_forcedisperse, m_NewtDormancyHumidity, m_NewtDormancyTemperature, m_newtwalkspeed, m_newtwalkstepsize, TAnimal::m_OurLandscape, MoveTo(), Landscape::SupplyHumidity(), Landscape::SupplyTempPeriod(), toNewts_Develop, and toNewts_Die.

Referenced by Step().

◆ st_EvaluateHabitat()

TTypeOfNewtState Newt_Juvenile::st_EvaluateHabitat ( void  )
protectedvirtual

Juvenile evaluate habitat behaviour.

Assesses where it is stood. If the habitat is good it sets the dispersal chance to m_goodhabitatdispersalprob otherwise to m_poorhabitatdispersalprob It then takes a prbobability test to determine whether to dispserse. Will return disperse or develop states depending on the result of the test.

Reimplemented in Newt_Female, Newt_Male, and Newt_Adult.

472  {
478  double chance = m_goodhabitatdispersalprob;
479  if (tole == tole_Pond)
480  {
481  m_forcedisperse = true;
482  return toNewts_Dispersal;
483  }
484  else
485  {
486  m_forcedisperse = false;
487  switch (tole) {
488  case tole_Marsh:
490  break;
491  default:
493  }
494  if (g_rand_uni() < chance) return toNewts_Dispersal;
495  }
496  return toNewts_Develop;
497 }
@ toNewts_Dispersal
Definition: Newt.h:71
TTypesOfLandscapeElement SupplyElementType(int a_polyref)
Definition: landscape.h:1110
static double m_poorhabitatdispersalprob
Probability of dispersal in poor habitat.
Definition: Newt.h:336
static double m_goodhabitatdispersalprob
Probability of dispersal in good habitat.
Definition: Newt.h:334
@ tole_NaturalGrassWet
Definition: tole_declaration.h:87
@ tole_Marsh
Definition: tole_declaration.h:41

References g_rand_uni, m_forcedisperse, m_goodhabitatdispersalprob, TAnimal::m_Location_x, TAnimal::m_Location_y, TAnimal::m_OurLandscape, m_poorhabitatdispersalprob, Landscape::SupplyElementType(), tole_Marsh, tole_NaturalGrassWet, tole_Pond, toNewts_Develop, and toNewts_Dispersal.

Referenced by Newt_Adult::st_EvaluateHabitat(), Newt_Female::st_EvaluateHabitat(), and Step().

◆ st_NextStage()

TTypeOfNewtState Newt_Juvenile::st_NextStage ( void  )
protectedvirtual

Juvenile maturation.

Creates a new Newt_Male or Newt_Female object and passes the data from the young to it, then signals young object removal.

391  {
395  struct_Newt sN;
397  sN.L = m_OurLandscape;
398  sN.age = m_Age;
399  sN.x = m_Location_x;
400  sN.y = m_Location_y;
401  sN.pondrefs = m_pondlist;
402  sN.weight = m_weight;
404  if (g_rand_uni()<0.5) m_OurPopulationManager->CreateObjects( tton_Male, NULL, &sN, 1 );
405  else m_OurPopulationManager->CreateObjects( tton_Female, NULL, &sN, 1 );
406  m_CurrentStateNo = -1;
407  m_StepDone = true;
408  return toNewts_Remove; // Not necessary, but for neatness
409 }
@ tton_Female
Definition: Newt.h:53
@ tton_Male
Definition: Newt.h:52
@ toNewts_Remove
Definition: Newt.h:70
Newt_Population_Manager * m_OurPopulationManager
This is a time saving pointer to the correct population manager object.
Definition: Newt.h:119
void CreateObjects(int ob_type, TAnimal *pvo, struct_Newt *data, int number)
Method for creating a new individual Newt.
Definition: Newt_Population_Manager.cpp:344
bool m_StepDone
Indicates whether the iterative step code is done for this timestep.
Definition: PopulationManager.h:118
int m_CurrentStateNo
The basic state number for all objects - '-1' indicates death.
Definition: PopulationManager.h:116
Used for creation of a new Newt object.
Definition: Newt_Population_Manager.h:47
bool reproinhib
Holds a reproductive effect flag.
Definition: Newt_Population_Manager.h:64
double weight
Newt weight.
Definition: Newt_Population_Manager.h:58
vector< unsigned > pondrefs
Born x-coord.
Definition: Newt_Population_Manager.h:56
int y
y-coord
Definition: Newt_Population_Manager.h:54
int age
The newt age.
Definition: Newt_Population_Manager.h:50
int x
x-coord
Definition: Newt_Population_Manager.h:52
Landscape * L
Landscape pointer.
Definition: Newt_Population_Manager.h:60
Newt_Population_Manager * NPM
Newt_Population_Manager pointer.
Definition: Newt_Population_Manager.h:62

References struct_Newt::age, Newt_Population_Manager::CreateObjects(), g_rand_uni, struct_Newt::L, Newt_Base::m_Age, TALMaSSObject::m_CurrentStateNo, TAnimal::m_Location_x, TAnimal::m_Location_y, TAnimal::m_OurLandscape, Newt_Base::m_OurPopulationManager, Newt_Base::m_pondlist, Newt_Base::m_reproductiveinhibition, TALMaSSObject::m_StepDone, m_weight, struct_Newt::NPM, struct_Newt::pondrefs, struct_Newt::reproinhib, toNewts_Remove, tton_Female, tton_Male, struct_Newt::weight, struct_Newt::x, and struct_Newt::y.

Referenced by Step().

◆ st_Overwinter()

TTypeOfNewtState Newt_Juvenile::st_Overwinter ( void  )
protectedvirtual

◆ Step()

void Newt_Juvenile::Step ( void  )
virtual

Newt_Juvenile Step code. This is called continuously until all animals report that they are 'DONE'.

Reimplemented from Newt_Base.

Reimplemented in Newt_Female, and Newt_Male.

353  {
354  if (m_StepDone || m_CurrentStateNo == -1) return;
355  switch (m_CurrentNewtState) {
356  case toNewts_InitialState: // Initial state always starts with develop
358  break;
359  case toNewts_Develop:
360  m_CurrentNewtState = st_Develop(); // Will return evaluate location, overwinter, next stage or die
361  break;
362  case toNewts_Dispersal:
364  break;
367  m_StepDone = true;
368  break;
369  case toNewts_Overwinter:
371  m_StepDone = true;
372  break;
373  case toNewts_NextStage:
374  st_NextStage();
375  break;
376  case toNewts_Die:
377  st_Dying(); // No return
378  m_StepDone = true;
379  break;
380  case toNewts_Remove:
381  m_CurrentStateNo = -1;
382  m_StepDone = true;
383  break;
384  default:
385  m_OurLandscape->Warn( "Newt_Juvenile::Step()", " unknown state" );
386  exit( 1 );
387  }
388 }
@ toNewts_InitialState
Definition: Newt.h:66
void Warn(std::string a_msg1, std::string a_msg2)
Definition: landscape.h:1579
void st_Dying(void)
Behavioural state dying.
Definition: Newt.cpp:87
virtual TTypeOfNewtState st_Overwinter(void)
Juvenile overwintering state.
Definition: Newt.cpp:500
virtual TTypeOfNewtState st_EvaluateHabitat(void)
Juvenile evaluate habitat behaviour.
Definition: Newt.cpp:472
virtual TTypeOfNewtState st_NextStage(void)
Juvenile maturation.
Definition: Newt.cpp:391
virtual TTypeOfNewtState st_Develop(void)
Juvenile development state.
Definition: Newt.cpp:412
virtual TTypeOfNewtState st_Disperse(void)
Juvenile dispersal state.
Definition: Newt.cpp:448

References Newt_Base::m_CurrentNewtState, TALMaSSObject::m_CurrentStateNo, TAnimal::m_OurLandscape, TALMaSSObject::m_StepDone, st_Develop(), st_Disperse(), Newt_Base::st_Dying(), st_EvaluateHabitat(), st_NextStage(), st_Overwinter(), toNewts_Develop, toNewts_Die, toNewts_Dispersal, toNewts_EvaluateLocation, toNewts_InitialState, toNewts_NextStage, toNewts_Overwinter, toNewts_Remove, and Landscape::Warn().

Member Data Documentation

◆ m_CurrentHabitat

TTypesOfLandscapeElement Newt_Juvenile::m_CurrentHabitat
protected

The current habitat type the newt is in.

Referenced by NewtDoWalking(), NewtDoWalkingCorrect(), and Newt_Adult::st_Migrate().

◆ m_forcedisperse

bool Newt_Juvenile::m_forcedisperse
protected

◆ m_goodhabitatdispersalprob

double Newt_Juvenile::m_goodhabitatdispersalprob = cfg_newtgoodhabitatdispersalprob.value()
static

Probability of dispersal in good habitat.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), and st_EvaluateHabitat().

◆ m_InPond

◆ m_JuvenileDailyWeightGain

double Newt_Juvenile::m_JuvenileDailyWeightGain = cfg_NewtJuvenileDailyLengthGain.value()
static

Used in determining daily growth.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), and st_Develop().

◆ m_JuvenilePPPEffectProbability_EnvConc

double Newt_Juvenile::m_JuvenilePPPEffectProbability_EnvConc = cfg_NewtJuvenilePPPEffectProbability_EnvConc.value()
static

The daily probability of effect if above m_JuvenilePPPThreshold for juveniles for environmental concentration.

Referenced by InternalPesticideHandlingAndResponse(), and Newt_Population_Manager::Newt_Population_Manager().

◆ m_JuvenilePPPEffectProbability_Overspray

double Newt_Juvenile::m_JuvenilePPPEffectProbability_Overspray = cfg_NewtJuvenilePPPEffectProbability_Overspray.value()
static

The daily probability of effect if above m_JuvenilePPPThreshold for juveniles for overspray.

Referenced by InternalPesticideHandlingAndResponse(), and Newt_Population_Manager::Newt_Population_Manager().

◆ m_JuvenilePPPElimRate

double Newt_Juvenile::m_JuvenilePPPElimRate = cfg_NewtJuvenilePPPToxEliminationRate.value()
static

The daily proportion of PPP body burden that is not eliminated for juveniles.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), and st_Develop().

◆ m_JuvenilePPPThreshold_EnvConc

double Newt_Juvenile::m_JuvenilePPPThreshold_EnvConc = cfg_NewtJuvenilePPPToxTrigger_EnvConc.value()
static

The environmental concentration threshold for effect of PPP on juveniles.

Referenced by InternalPesticideHandlingAndResponse(), and Newt_Population_Manager::Newt_Population_Manager().

◆ m_JuvenilePPPThreshold_Min

double Newt_Juvenile::m_JuvenilePPPThreshold_Min = 0
static

The minimum threshold for effect of PPP on juveniles.

Class Newt_Juvenile represents the juvenile stage of the newt.
In addition to inherited attributes from Newt_Larva, each juvenile has:

  • m_weight which is the weight of the newt in g
  • m_SimW - the width of the simulation map, a static variable used for speed
  • m_SimH - the height of the simulation map, a static variable used for speed
  • m_CurrentHabitat - the current habitat type the newt is located in
  • m_InPond is the polyrefindex for the pond the newt is in, or -1 if not in a pond
  • m_SimW The width of the simulation map, stored for fast access
  • m_SimH The height of the simulation map, stored for fast access
  • m_OurVector The last direction the newt moved in

Other new attributes are included here for efficient storage of input parameters

New behaviours are introduced here:

  • st_Disperse this moves the newts out of and away from the pond
  • st_Overwinter this is where the newt enters a semi-torpid state over winter (ie does not move).

Referenced by InternalPesticideHandlingAndResponse(), and Newt_Population_Manager::Newt_Population_Manager().

◆ m_JuvenilePPPThreshold_Overspray

double Newt_Juvenile::m_JuvenilePPPThreshold_Overspray = cfg_NewtJuvenilePPPToxTrigger_Overspray.value()
static

The overspray threshold for effect of PPP on juveniles.

Referenced by InternalPesticideHandlingAndResponse(), and Newt_Population_Manager::Newt_Population_Manager().

◆ m_NewtDormancyHumidity

double Newt_Juvenile::m_NewtDormancyHumidity = cfg_newtdormancyhumidity.value()
static

Temperature in degrees that the newts become dormant.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), st_Disperse(), and Newt_Adult::st_Disperse().

◆ m_NewtDormancyTemperature

double Newt_Juvenile::m_NewtDormancyTemperature = cfg_newtdormancytemp.value()
static

◆ m_newtwalkspeed

int Newt_Juvenile::m_newtwalkspeed = cfg_NewtWalkSpeed.value()
static

The max walking speed of a newt.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), st_Disperse(), and Newt_Adult::st_Migrate().

◆ m_newtwalkstepsize

int Newt_Juvenile::m_newtwalkstepsize = cfg_NewtWalkStepsize.value()
static

The size of a step when evaluating habitat during walking.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), st_Disperse(), Newt_Adult::st_Disperse(), and Newt_Adult::st_Migrate().

◆ m_OurVector

unsigned Newt_Juvenile::m_OurVector
protected

The last direction we moved in.

Referenced by Newt_Adult::CalcMovementVector(), MoveTo(), Newt_Juvenile(), ReInit(), and Newt_Adult::st_Migrate().

◆ m_poorhabitatdispersalprob

double Newt_Juvenile::m_poorhabitatdispersalprob = cfg_newtpoorhabitatdispersalprob.value()
static

Probability of dispersal in poor habitat.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), and st_EvaluateHabitat().

◆ m_roadmortalityprob

double Newt_Juvenile::m_roadmortalityprob = cfg_NewtRoadMortalityProb.value()
static

The probability of death when crossing a road.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), NewtDoWalking(), and NewtDoWalkingCorrect().

◆ m_SimH

int Newt_Juvenile::m_SimH = 0
static

The height of the simulation map, stored for fast access.

Referenced by MoveTo(), Newt_Population_Manager::Newt_Population_Manager(), NewtDoWalkingCorrect(), and Newt_Adult::st_Migrate().

◆ m_SimW

int Newt_Juvenile::m_SimW = 0
static

The width of the simulation map, stored for fast access.

Referenced by MoveTo(), Newt_Population_Manager::Newt_Population_Manager(), NewtDoWalkingCorrect(), and Newt_Adult::st_Migrate().

◆ m_weight

double Newt_Juvenile::m_weight
protected

/brief The weight of the newt in grammes

Referenced by GetWeight(), Newt_Juvenile(), ReInit(), SetWeight(), st_Develop(), and st_NextStage().


The documentation for this class was generated from the following files: